1. Field of the Invention
The subject disclosure relates to quantum computing and related components, and more particularly to improved quantum computing gates, quantum computing memory registers, quantum computing switches and quantum computing routers using a data transmission process that collapses the data to a point value and reconstructs the data thereafter.
2. Background of the Invention
Classical computers are constructed from sets of electrical circuits containing wires and logic gates where the wires convey information around the circuit and the logic gates manipulate the information. The only non-trivial example of a classical single-bit logic gate is the NOT gate, whose operation is defined by its truth table, in which 0→1 and 1→0, meaning that the 0 and 1 states are interchanged.
FIG. 1 summarizes elementary classical (non-quantum) computing single- and multiple-bit logic gates 10 and their truth tables 12. Classical AND, NAND, OR, XOR and NOR gates receive two bits as input, and generate a single bit as output; the NOT gate receives and generates a single bit as input and output, respectively. The AND gate outputs 1 if and only if both of its inputs are 1. The NAND and NOR gates take the AND and OR, respectively, of their inputs, and apply a NOT function to the output. The XOR gate outputs the sum modulo 2 of its inputs.
Two classical gates not shown in FIG. 1 are the FANOUT and CROSSOVER gates. The FANOUT circuit gate enables bits to divide, that is, it replaces a bit with two copies of itself. The CROSSOVER gate interchanges the value of two bits. FIG. 1 also does not illustrate the preparation of additional ancilla or work bits, that create additional working space during classical computation.
Circuit elements ranging from simple to highly complex are routinely assembled from combinations of all of these classical gates to compute all possible classical functions. Five major elements that are utilized in universal circuit construction include: i) Wires, that preserve the states of bits; ii) Ancilla bits prepared in standard states and used in the n=1 case of a given proof; iii) The CROSSOVER operation; iv) The FANOUT operation; and v) The AND, XOR and NOT gates.
The limits of this time-tested approach to computing can be seen on the horizon. An extrapolation of the exponential trend of miniaturization, which has held since 1950 under Moore's Law, indicates the attainment of a limit of single-atom bits and Single Electron Transistors (SETs). Prior to efficient attainment of the single-atom bit and single-electron transistor scales, it will be necessary to use quantum effects to read bits from and write bits to the memory registers of nano-, pico-, (and soon thereafter) femto-, atto-, zepto- and yocto-scale computers and network nodes.
Moore's Law is exponential; any classical approach demands exponential increases in space or time. Even the Avagadro's number of elements in a molecular computer is quickly limited by the size of the exponential problem. Of all the candidate technologies to continue scaling beyond the Very Large Scale Integration (VLSI) era, quantum logic has one unique feature. Quantum computing accesses Hilbert space, the one exponential resource that has been untapped for computation.
Two essential bases to quantum computer and network systems are:                Fermions (named after the Italian physicist Enrico Fermi), which have ½-integer spin and cannot be in the same state due to the Pauli exclusion principle, and        Bosons (named after the Indian physicist Satyendra Bose), which have integer spin and can share the same state.Electrons are fermions, and photons are bosons. Electronic computing and networking is ultimately fermion-based, where N8 must be either 0 or 1 because there cannot be more than one fermion in a single state. Optical computing and networking are ultimately boson-based, where, for bosons, the sum over N8 runs from 0 to ∞.        
Bosons (the ultimate basis of optical computing and networking) are particles whose spin is a whole number. Fermions (the ultimate basis of electronic computing and networking) are particles whose spin is half of a whole (odd) number—tend to give canceling quantum-mechanical contributions.
When the quantum jitters of a boson are positive, those of a fermion tend to be negative, and vice versa. Since supersymmetry ensures that bosons and fermions occur in pairs, substantial cancellations occur from the outset—cancellations that ultimately calm the apparently frenzied quantum effects.
Continuing trends in miniaturization have ushered in the inexorable requirement to use quantum physics to describe the elementary and complex operations of computers and networks. Classical models of computation, based on a mathematical idealization known as the Universal Turing Machine, are rendered invalid at the atomic (10−10 meter) and electronic/photonic (10−12 meter) quantum computational scales. At these or more expressed junctures, the entire spectrum of computing and computer networking—from design of quantum algorithms, to loading programs, loading network configurations, to running programs and configurations, to reading results—will necessarily be dominated by quantum effects.
While the Universal Turing Machine model is essentially flawed outside of classical physics-based computations, it is, however, as applicable today as it was at its inception by Alan Turing in 1936 (it is noteworthy that Alonso Church, Kurt Godel and Emil Post each independently created mathematical models of the computing process around the same period). The Deterministic Turing Machine (DTM) model consists of an infinitely long tape that is marked off into a sequence of cells on which can be written a ‘0’, a ‘1’, or a blank, and a read/write head that is able to move back and forth along the tape scanning the contents of each tape cell. The head therefore, can exist in one of a finite number of internal states and contains a set of instructions (that constitute the program) specifying how the state must change given the bit currently being read under the head, whether the bit should be subsequently changed, and in which direction the head should then be advanced. Unfortunately, the Turing model proves that, given sufficient time and memory capacity, there is not a single computation that a supercomputer can perform that a personal computer could not also perform.
The Probabilistic Turing Machine (PTM) model incorporates a DTM with the ability to make a random choice. The PTM has multiple possible successor states available to any given state, whereas a DTM, in a given state, reading a certain symbol, has precisely one successor state available to itself. However, the probabilistic computation model introduces tradeoffs between the time required to return an answer to a given computation, and the probability that the returned answer is correct. Therefore, if a correct answer is required (almost certainly always the case) uncertainty is encountered in the length of time a probabilistic algorithm must run. The Turing Machine model has been known to contain fundamental flaws since the early 1980s when it first became evident that DTM and PTM models were bounded by classical space-time symmetry physics. As computers, network nodes and their components increasingly miniaturize, their behavior must be properly described through the physics appropriate for small scales—quantum physics.
The first truly quantum Turing machine (QTM) was described in 1985 by David Deutsch of Oxford University following initial descriptions of quantum mechanical computation by Richard Feynman of Caltech in 1982. Whereas a classical Turing machine could only encode a ‘0’, ‘1’, or blank in each cell of its tape, a QTM could encode a blend, or “superposition,” of ‘0’, and ‘1’ simultaneously. Quantum computing superposition encoding enables performance of calculations on all of the inputs in the time required to perform just one calculation classically, and is known as quantum parallelism.
The determination that each bit in a QTM can be a blend of a ‘0’ and a ‘1’ can be illustrated by representing each quantum bit, or qubit, as a vector contained within a sphere where a “straight up” position represents the (classical) binary value of ‘0’, a “straight down” position represents the (classical) binary value of ‘1’, and when the vector is at any other position, the angle the vector makes with the vertical axis is a measure of the ratio of ‘0-ness’ to ‘1-ness’ within the qubit. The angle made by this vector with the vertical axis is related to the relative contributions of the |ψ0> and |ψ1> eigenstates to the whole state. Therefore, a given qubit state can have equal proportions of ‘0-ness’ and ‘1-ness’ but actually displays differential amplitudes due to different phase factors.
A QTM can be considered as a quantum mechanical generalization of a PTM with the significant difference that in a classical PTM only one particular computational trajectory is followed, whereas within a QTM all computational trajectories are followed and the resulting superposition results from the summation over all possible trajectories achievable in time t.
FIG. 2 represents a qubit both in terms of electronic states within an atom 14, and as points on a unit three-dimensional sphere called a Bloch sphere 16. Quantum computers are built from quantum circuits containing wires and elementary quantum gates that propagate and manipulate quantum information. Changes that occur to a quantum state can be described using the language of quantum computation. A process that transforms the quantum state |0> to |1> suggests a quantum logic analog to the classical NOT operation. However, specifying the action of the gate on the states |0> and |1> does not necessarily reveal what happens to superpositions of the states |0> and |1>. In fact, the quantum NOT gate behaves linearly, that is, it transforms the stateα|0>+β|1>  (Formula 1)to the corresponding state in which the roles of |0> and |1> are interchanged:α|1>+β|0>.  (Formula 2)Linear behavior is a general property of quantum computational systems. Therefore, we can define a matrix X to represent the quantum NOT gate as
                    X        ≡                              [                                                            0                                                  1                                                                              1                                                  0                                                      ]                    .                                    (                  Formula          ⁢                                          ⁢          3                )            The quantum state α|0>+β|1> is written in vector notation as
                              [                                                    α                                                                    β                                              ]                ,                            (                  Formula          ⁢                                          ⁢          4                )            where the top entry represents the amplitude for |0> and the bottom entry represents the amplitude for |1>, resulting in the following output from the quantum NOT gate
                              χ          ⁡                      [                                                            α                                                                              β                                                      ]                          =                              [                                                            β                                                                              α                                                      ]                    .                                    (                  Formula          ⁢                                          ⁢          5                )            Single-qubit quantum gates can be described by 2×2 matrices where the only constraint is the matrix U describing the single qubit gate be unitary, that is, U, U=I, where U is the adjoint of U (this is obtained by transposing and then complex-conjugating U), and where I is the 2×2 identity matrix.
Two significant single-qubit gates are the Z gate and the Hadamard gate. The Z gate leaves |0> unchanged and flips the sign of |1> to −|1>:
                    Z        ≡                              [                                                            1                                                  0                                                                              0                                                                      -                    1                                                                        ]                    .                                    (                  Formula          ⁢                                          ⁢          6                )            The Hadamard gate (also known as the ‘square-root of NOT’ gate), transforms a |0> into a [(|0>+|1>)/√2] (first column of the H matrix, midpoint between |0> and |1>), and transforms a |1> into a [(|0>−|1>)/√2] (second column of the H matrix, also at the midpoint between |0> and |1>):
                    H        ≡                                            1                              2                                      ⁡                          [                                                                    1                                                        1                                                                                        1                                                                              -                      1                                                                                  ]                                .                                    (                  Formula          ⁢                                          ⁢          7                )            Hadamard gate properties for quantum computation can be understood fundamentally as an arbitrary qubit unitary gate that can be decomposed as a product of rotations and reflections of a Bloch sphere, where the Hadamard operation is a rotation of the sphere about the y axis by 90°, followed by a reflection through the x-y plane. In general, an arbitrary single qubit unitary gate can be decomposed as a product of rotations as
                    [                                                            cos                ⁢                                  Υ                  2                                                                                                      -                  sin                                ⁢                                  Υ                  2                                                                                                        sin                ⁢                                  Υ                  2                                                                                    cos                ⁢                                  Υ                  2                                                                    ]                            (                  Formula          ⁢                                          ⁢          8                )            and a gate can be represented as being a rotation about the z axis with a global phase shift expressed as a constant multiplier of the form eiα:
                    [                                                            ⅇ                                                      -                    i                                    ⁢                                                                          ⁢                                      β                    /                    2                                                                                      0                                                          0                                                      ⅇ                                  i                  ⁢                                                                          ⁢                                      β                    /                    2                                                                                      ]                            (                  Formula          ⁢                                          ⁢          9                )            In general, quantum computation (the quantum circuit model of computation) requires the following key elements:                Suitable state space; quantum computational circuits operate on some number, n, of qubits, therefore, the quantum computational state space is a 2n-dimensional Hilbert space, with product state of the form |X1, . . . , Xn>, where (Xi=0,1) are called computational basis states.        Any computational basis state |X1, . . . , Xn> can be prepared in ≦n steps.        Quantum gates that can be applied to any subset of qubits and a universal family of gates that can be implemented.        Ability to perform measurements in the computational basis of ≧1 qubit(s).        Inherent ability to perform classical (non-quantum) computations if quantum computations are not required.        
FIG. 3 summarizes single-qubit (quantum computing) gates 18 and their corresponding Unitary matrices 20. The overall purpose of all computational logic gates is to enable the processing of algorithms—classical and quantum. From a single-qubit gate perspective, a qubit is a vector |ψ>=a|022 +b|0> that is parameterized by two complex numbers that satisfy |a|2+|b|2=1. A single qubit in the state a|0>+b|1> can be visualized as a point (θ, φ) on the Bloch unit sphere [the vector (cos φ sin θ, sin φ sin θ cos θ) is the Bloch vector], where a=cos(θ/2), b=eiφ sin(θ/2), and a is assumed to be real since the overall phase of the state is unobservable.
FIG. 4 depicts the prototypical controlled-NOT (CNOT) quantum logic gate 22 and a matrix representation thereof 24. CNOT is a quantum gate with two input qubits—the control qubit and target qubit, respectively. The action of the CNOT gate is given by |c>|t>→|c>|t⊕c> where ⊕ is addition modulo 2 and, if the control qubit is set to |1> then the target qubit is flipped, otherwise, the target qubit is not changed. The control and target qubits are XORed and stored in the target qubit.
The Toffoli gate 26 and its corresponding truth table 28 is shown in FIG. 5 and is interesting because it can be implemented both as a classical and as a quantum logic gate. One of its main roles as a quantum gate is to enable simulation of classical logic circuitry. Whereas several classical logic gates such as the NAND gate are inherently irreversible, any classical circuit can be replaced by an equivalent quantum circuit containing only reversible elements through use of the reversible Toffoli quantum gate. The Toffoli gate has three input bits and three output bits, where two of the bits are control bits that are unaffected by the action of the gate. The third bit is a target bit that is flipped if both control bits are set to 1, otherwise the target bit is not changed. Reversibility of the Toffoli gate is shown by applying the gate twice to a set of bits as [(a,b,c)→(a,b,c⊕ab)→(a,b,c)].
Quantum logic gates are the basic units of quantum computational algorithms just as classical logic gates are the basic units of classical computational algorithms. The major distinction between the quantum and classical computational contexts is that quantum gates must be implemented unitarily and, in particular, must incorporate reversible operations. The OR statement on two classical bits, for example, is not invertible since the four possible inputs {00, 01, 10, 11} map onto only two possible outputs {0, 1}.
Major quantum algorithmic classes include:
Classical computations on a quantum computer; enabled, for example, by the Toffoli gate.
Quantum parallelism; a feature of several quantum algorithms that enables quantum computers to evaluate a function ƒ(x) for multiple different values of x simultaneously. If, for example, ƒ(x): {0,1}→{1,0} is a function with a one-qubit domain and range, and a two-qubit quantum operation initializes in the state |x, y>, an appropriate sequence of quantum logic gates can transform this state →|x,y⊕ƒ(x)>, where ⊕ is addition modulo 2, the first register is the data register, and the second register is the target register. The transformation map |x,y>→|x,y⊕ƒ(x)> is unitary (Uƒ). Quantum circuits can be constructed that apply Uƒ to inputs not in the computational basis and where the data register is prepared in the superposition (|0>+|1>)/√□. A Hadamard gate, for example, acts on |0>, then Uƒ is applied, with the resulting state |0,ƒ(0)>+|1,ƒ(1)>/√□. This result contains information about both ƒ(0) and ƒ(1). A single quantum ƒ(x) circuit has therefore been used to evaluate the function for multiple values of x simultaneously.
Deutsch's algorithm; this quantum algorithm combines quantum parallelism with the interference property of quantum mechanics, resulting in the ability to determine a global property of ƒ(x), that is, ƒ(0)⊕ƒ(1), through a single evaluation of ƒ(x). The Deutsch-Jozsa algorithm is related.
Quantum simulation algorithm; simulation seeks to solve differential equations that capture laws governing the dynamic behavior of a system. Classical computation cannot effectively simulate quantum system behavior as even simple quantum systems are governed by Schrödinger's equation
                              i          ⁢                                          ⁢          ℏ          ⁢                      ⅆ                          ⅆ              t                                ⁢                                  ψ            〉                          =                  H          ⁢                                  ψ            〉                                              (                  Formula          ⁢                                          ⁢          10                )            and a significant issue is the exponential (2n) number of differential equations that must be solved. The quantum simulation algorithm is concerned with the solution ofid|ψ>/dt=H|ψ>  (Formula 11)which, for a time-dependent H, is|ψ(t)>=e−iHt|ψ(0)>  (Formula 12)
Quantum Fast Fourier Transform (QFFT); The QFFT is the key component of quantum factoring, order-finding, period-finding, order of a permutation, hidden linear function, and Abelian stabilizer algorithms. The discrete (non-quantum) Fast Fourier Transform (FFT) receives as input a vector of complex numbers, x0, . . . , xN−1 where the length N of the vector is fixed. The transformed data is output as a vector of complex numbers y0, . . . , yN−1 where
                              y          k                ≡                              1                          N                                ⁢                                    ∑                              j                =                0                                            N                -                1                                      ⁢                                                  ⁢                                          x                j                                                                              ⁢                                                ⅇ                                                            2                      ⁢                      π                      ⁢                                                                                          ⁢                      i                      ⁢                                                                                          ⁢                                              jk                        /                        N                                                              ⁢                                                                                                                .                                                                        (                  Formula          ⁢                                          ⁢          13                )            QFFT performs the same transformation as the classical FFT, with the notable exception that the quantum transform is computed on an orthonormal basis |0>, . . . , |N−1>, where a linear operator performs the following on the basis states:
                                        j          〉                →                              1                          N                                ⁢                                    ∑                              k                =                0                                            N                -                1                                      ⁢                                                  ⁢                                          ⅇ                                                      2                    ⁢                    π                    ⁢                                                                                  ⁢                    i                    ⁢                                                                                  ⁢                                          jk                      /                      N                                                        ⁢                                                                                                    ⁢                                                                  k                  〉                                .                                                                        (                  Formula          ⁢                                          ⁢          14                )            The QFFT action on an arbitrary state is
                                                        ∑                              j                =                0                                            N                -                1                                      ⁢                                                  ⁢                                          x                j                            ⁢                                              j                〉                                              →                                    ∑                              k                =                0                                            N                -                1                                      ⁢                                          y                k                            ⁢                                              k                〉                                                    ,                            (                  Formula          ⁢                                          ⁢          15                )            where the amplitudes yk are the discrete Fourier transform of the amplitudes xj.
Quantum factoring; finding the prime factorization of an n-bit integer requires approximately exp(Ξ(n1/3 log2/3 n)) operations using the classical number field sieve, is exponential in the size of the number being factored, and therefore quickly becomes an intractable problem with increasing values of n. By contrast, quantum computers can factor any number exponentially faster than the most efficient classical factoring algorithms, using O(n2 log n log log n) operations.
Quantum search algorithm (a.k.a. Grover's algorithm); rather than search through a space of N elements directly, a quantum oracle can be invoked to, for example, focus on the index to those elements, which is a number 0≦element index≦N−1. If N=2n, the index can be stored in n qubits, and the quantum search problem will have M solutions, with 1≦M≦N. The quantum search oracle obtains a search solution within O(√N/M) iterations. In general, quantum search problems can be formulated in terms of an oracle ƒ(x) that equals 1 for arguments x that solve the problem of interest, where x may be, for example, a pair of integers and ƒ(x) a check for prime factors, or x may be database entries and ƒ(x) a test for answers to a query. Lov Grover has shown that a quantum computer can solve the quantum search problem in √N steps. The quantum search algorithm is also referred to as the database search algorithm where a quantum database is structured in quantum memory containing N=2n cells of l qubits each and the contents dx of the xth memory cell are added to the data register as |d>→|d⊕dx>, and where the addition is performed bitwise, modulo 2.
Quantum counting; classical computation requires Ξ(N) iterations with an oracle to determine the number of solutions, M, to an N item search problem if M is not known in advance. Quantum counting estimates the number of solutions significantly more rapidly by combining the Grover iteration with the phase estimation technique based upon the QFFT.
Quantum cryptography; classical cryptography includes private key and public key systems. The major challenge within private key cryptosystems is secure distribution of key bits. Quantum cryptography, or quantum key distribution (QKD) uses the principles of quantum mechanics to enable provably secure distribution of private information, and utilizes quantum corollaries of classical private cryptography, information reconciliation (error-correction conducted over a public channel) and privacy amplification. QKD is provably secure in that private key bits can be created between two parties over a public channel and the key bits can be used to implement a classical private key cryptosystem, enabling parties to communicate securely.
The QKD protocol transmits non-orthogonal qubits over a public channel. The sender and receiver establish an upper bound on any noise or eavesdropping occurring within their communication channel through the use of ‘check’ qubits that are randomly interspersed among data qubits. Information reconciliation and privacy amplification are then performed to distill a shared secret key string with security of the resulting key ensured by the properties of quantum information.
Three QKD protocol cases are BB84, B92 and EPR, used in quantum teleportation. In the BB84 QKD protocol, for example, one user, Alice, initializes with a and b, two strings each of (4+δ)n random classical bits, which are next encoded as strings of a block of (4+δ)n qubits (cooperating quantum cryptographic users are generally referred to as Bob and Alice, and someone attempting to eavesdrop into a quantum communication channel is by convention referred to as Eve). These bits are next encoded as strings of a block of (4+δ)n qubits,
                                                      ψ            〉                    =                                                    ⊗                                                      (                                          4                      +                      δ                                        )                                    ⁢                  n                                                            k                =                1                                      ⁢                                                        ψ                ⁢                                                                  ⁢                                  a                  k                                ⁢                                  b                  k                                            〉                                      ,                            (                  Formula          ⁢                                          ⁢          16                )            where ak is the kth bit of a, bk is the kth bit of b, and each qubit is one of the four states|ψ00>=|0>|ψ10>=|1>|ψ01>=|+>=(|0>+|1>)√{square root over (2)}|ψ11>=|−>=(|0>−|1>)√{square root over (2)}.  (Formula 17)
The four states of Formula 17 are not all mutually orthogonal and therefore no measurement can distinguish among all of them with certainty. At this point, Alice sends |ψ> to Bob over a public quantum communication channel. Bob receives ε(|ψ><ψ|), where ε describes the quantum operation that results from the combined effect of the channel between Bob and Alice, and to any possible eavesdropping actions by Eve. Bob then publicly announces this quantum operation state set and each of the three then has their unique quantum state set described by separate density matrices. It is also true that Alice has not revealed b and the noise ε may be a poor channel artifact in addition to possible eavesdropping by Eve.
Bob next measures each qubit in basis X or Z, as determined by a random (4+δ)n bit string b′ which he creates, with his measurement result=a′. Next, Alice publicly announces b. Then, by public channel communication, Bob and Alice discard all bits in {a′, a} except those for which corresponding bits of b′ and b are equal. The remaining bits satisfy a′=a. Alice then randomly selects n bits (of a mutual 2n bits) and announces the selection to Bob over a public channel. They both then publish and compare the value of these check bits and, if more than t bits disagree, they re-initialize the protocol. If t is mutually selected, they can then apply information reconciliation and privacy amplification algorithms to obtain m acceptably secret shared key bits from the remaining n bits.
Quantum Error-Correcting Codes; Classical network error detection and correction is well known and in prevalent use at multiple architectural layers. There are two basic approaches generally taken in classical (non-quantum) network designs for handling transmission errors: (1) Include sufficient redundant information with each block of data sent to enable the receiver to deduce the transmitted character correctly (error-correcting codes), or (2) Incorporate only sufficient redundancy to allow the receiver to determine that a transmission error has occurred (error-detecting codes).
Very generally, transmitted classical frames consist of m data bits and r redundant bits, or checkbits, where the total length equals n(n=m+r). An n-bit classical network transmission unit that contains data and checkbits is referred to as an n-bit codeword. Given two possible codewords, for example 10001001 and 10110001, an EXCLUSIVE OR (XOR) logic operation using modulo-2 arithmetic and yielding a remainder can determine that they differ by three bits. The number of bit positions in which a pair of codewords differs is the Hamming distance. This is significant because two codewords that are a Hamming distance d apart will require d single-bit errors to convert one into the other.
It was originally thought that analogous error-correction techniques would not apply to the quantum network transmission of qubits, due to the assumption that qubit measurement would force the collapse of the qubit into a specific state, therein losing superpositionality. It was also noted that an inherent problem exists with copying or cloning an arbitrary quantum state.
However, others have developed nine-, seven-, and five-qubit error-correcting codes (algorithms). For example, in U.S. Pat. No. 5,768,297 to Shor a nine-qubit error-correcting code is disclosed. Shor's nine-qubit error-correcting code, for example, presumes that one qubit is encoded into nine qubits via the following scheme:α|0>+β|1>→α(|000>+|111>)⊕(|000>+|111>)⊕(|000>+|111>) β(|000>+|111>)⊕(|000>+|111>)⊕(|000>+|111>),  (Formula 18)where constant factors that can be recovered from the normalization are ignored. Once the nine qubits are received, the goal of the algorithm is to recover the original superposition, assuming that no greater than one Pauli-type error has occurred within the quantum network. Shor's code invokes specific quantum entanglements with additional, or ancillary, qubits and measures the ancillary qubits to correct any error. The process of error correction must be accomplished while retaining the original quantum information superposition.
Shor's code is a combination of the three-qubit phase-flip and bit-flip codes. In this algorithm, the qubit is first encoded using the phase-flip code:|0>→|+++>,|1>→|−−−>.  (Formula 19)The second step is to encode each of the qubits using the three-qubit phase-flip code. |+> is encoded as (|000>+|111>)√2, and |−> is encoded as (|000>−|111>)√2. This results in a nine-qubit code with codewords given by
                                                      0            〉                    →                                                                  0                L                            〉                        ≡                                                            (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                ⁢                                  (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                ⁢                                  (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                                            2                ⁢                                  2                                                                    ⁢                                  ⁢                            1          〉                →                                                        1              L                        〉                    ≡                                                                      (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                ⁢                                  (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                ⁢                                  (                                                                                  000                      〉                                        +                                                                111                      〉                                                        )                                                            2                ⁢                                  2                                                      .                                              (                  Formula          ⁢                                          ⁢          20                )            
FIG. 6 illustrates the quantum circuit 30 encoding the Shor algorithm. The first part of the circuit encodes the qubit using the three-qubit phase-flip code as described above. The second part of the circuit encodes each of these three qubits using the bit-flip code through use of three copies of the bit-flip encoding circuit. The result is that the Shor code can protect against phase-flip and qubit-flip errors on any qubit.
Quantum error-detection and error-correction can also be performed in the absence of measurement, using only unitary operations and ancilla systems prepared in standard quantum states. This technique is essentially the same as those used for modeling arbitrary quantum computing and networking operations. The major advantage of quantum error-detection and error-correction in the absence of measurement is that it becomes increasingly difficult for real-world quantum information systems to render a reliable procedure to perform quantum measurements. In essence, the solution is to introduce an ancilla system with basis states, |i>, corresponding to possible error syndromes, where that system initializes in a standard pure state, |0>, prior to error-correction. A unitary operator, U, is then defined on the principal system plus ancilla and operates on the whole state space. The result is that U preserves inner products and can also be extended to a unitary operator on the entire (Hilbert) state space.
In view of the above, several systems have been developed to utilize quantum computing. Techniques for maintaining and transmitting states are evolving. Some examples are illustrated in U.S. Pat. No. 5,768,297 to Shor and U.S. Publication No. 2002/0030186 to Tomita, and are incorporated herein by reference. However, none of these techniques have accomplished developing components that are extensible and interconnective on a cosmological level.
The currently observable universe is thought to have a scale of approximately 1027 meters (m), the atomic scale is 10−10 m, and there are thought to be 1080 atoms in the observable universe. Quantum computing and networking is ushered in at the nano-scale (10−9 m) and functions intrinsically at the Angstrom (atomic, 10−10 m) and pico (photonic/electronic, 10−12 m) scales due to the earlier statement that classical (non-quantum) models of computation, based on a mathematical idealization known as the Universal Turing Machine, are rendered invalid at the atomic (10−10 m) and electronic/photonic (10−12 m) scales. This is due, as stated earlier to the extrapolation of the exponential trend of miniaturization, which has held since 1950 under Moore's Law, indicating the attainment of a classical computational limit of single-atom bits and single-electron transistors (SETs) by the year 2010, beyond which continued miniaturization and computational operation becomes classically infeasible.
The entire spectrum of computing and computer networking—from design of quantum algorithm, to loading program, loading network configurations, to running programs and configurations, to measuring and reading results—will be necessarily increasingly dominated by quantum effects at Angstrom (10−10 m) and smaller scales. Non-quantum wires cannot be thinner than a single atom; classical (non-quantum memories) cannot have fewer than one electron.
As can be seen from the discussion above, quantum computing can provide significant advantages over classical methods. Therefore, there is a need for improved components to allow utilizing the advantages that quantum computing can offer.